import { defineStore } from 'pinia'
import request from '../utils/request'
import axios from 'axios'
import { login, getUserInfo, resetUserInfo } from '../services/auth'
import { resetAllRequests } from '../utils/request'
import { ElMessage } from 'element-plus'
import type { ApiResponse, PaginationResponse } from '@/types/api'
import config from '../config/index'
import { userApi } from '../api/user'

// 定义用户接口
interface User {
  id: number
  username: string
  name: string
  nickname: string
  thumb: string
  sex: number
  mobile: string
  phone: string
  email: string
  did: number
  department_ids: string
  position_id: number
  type: number
  status: number
  entry_time: string
  reg_pwd: string
  salt: string
  pwd: string
  last_login_time: string
  last_login_ip: string
  create_time: number
  update_time: number
  // 扩展字段
  department?: string
  position?: string
  departments?: string
  pname?: string
  department_names?: string
}

// 定义验证码接口
interface Captcha {
  id: string
  image: string // Base64 encoded image
}

// 定义部门接口
interface Department {
  id: number
  pid: number
  title: string
  leader_ids: string
  sort: number
  remark: string
  status: number
  create_time: number
  update_time: number
  // 扩展字段
  leader?: string
  children?: Department[]
}

// 定义岗位接口
interface Position {
  id: number
  title: string
  remark: string
  status: number
  create_time: number
  update_time: number
  // 扩展字段
  groupName?: string
  group_id?: number[]
}

interface UserInfo {
  id: number
  username: string
  nickname: string
  avatar: string
  department?: string
  position?: string
  create_time?: string
  menu?: any[] // 可选的菜单属性
}

interface UserState {
  users: User[]
  userTotal: number
  departments: Department[]
  positions: Position[]
  positionTotal: number
  userInfo: UserInfo
  token: string | null
  isLogin: boolean
  captcha: Captcha | null
  permissions: string[] // 添加权限数组
}

// 使用导入的userApi对象

/**
 * 用户状态管理Store
 * 处理用户登录、信息获取、退出等操作
 */
export const useUserStore = defineStore('user', {
  state: (): UserState => ({
    users: [],
    userTotal: 0,
    departments: [],
    positions: [],
    positionTotal: 0,
    userInfo: { id: 0, username: '', nickname: '', avatar: '' },
    token: localStorage.getItem('token'),
    isLogin: !!localStorage.getItem('token'),
    captcha: null,
    permissions: [], // 添加权限数组初始值
  }),

  actions: {
    // 获取用户列表
    async getUserListAction(params: any) {
      try {
        const res: any = await userApi.getUserList(params)
        if (res.code === 0) {
          this.users = res.data.list
          this.userTotal = res.data.total || 0
        }
        return res
      } catch (error) {
        throw error
      }
    },

    // 添加用户
    async addUserAction(data: any) {
      try {
        const res: any = await userApi.addUser(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 编辑用户
    async editUserAction(data: any) {
      try {
        const res: any = await userApi.editUser(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 禁用/恢复用户
    async setUserStatusAction(data: any) {
      try {
        const res: any = await userApi.setUserStatus(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 重置用户密码
    async resetUserPasswordAction(data: any) {
      try {
        const res: any = await userApi.resetUserPassword(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 修改用户密码
    async changePasswordAction(data: { old_password: string; new_password: string }) {
      try {
        const res: any = await userApi.changePassword(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 添加获取部门选项的方法（用于下拉选择）
    async getDepartmentOptionsAction(params?: any) {
      try {
        const res: any = await userApi.getDepartmentOptions(params)
        return res
      } catch (error) {
        throw error
      }
    },

    // 获取部门列表
    async getDepartmentListAction() {
      try {
        const res: any = await userApi.getDepartmentList()
        if (res.code === 0) {
          this.departments = res.data
        }
        return res
      } catch (error) {
        throw error
      }
    },

    // 添加/编辑部门
    async saveDepartmentAction(data: any) {
      try {
        // 根据ID是否存在来选择调用添加或编辑接口
        if (data.id) {
          // 编辑模式
          const res: any = await userApi.editDepartment(data)
          return res
        } else {
          // 新增模式：使用正确的API路径 /add
          const res: any = await userApi.saveDepartment(data)
          return res
        }
      } catch (error) {
        throw error
      }
    },

    // 删除部门
    async deleteDepartmentAction(id: number) {
      try {
        const res: any = await userApi.deleteDepartment(id)
        return res
      } catch (error) {
        throw error
      }
    },

    // 添加获取岗位选项的方法（用于下拉选择）
    async getPositionOptionsAction() {
      try {
        const res: any = await userApi.getPositionOptions()
        return res
      } catch (error) {
        throw error
      }
    },

    // 获取岗位列表
    async getPositionListAction(params: any) {
      try {
        const res: any = await userApi.getPositionList(params)
        if (res.code === 0) {
          this.positions = res.data
          this.positionTotal = res.count || 0
        }
        return res
      } catch (error) {
        throw error
      }
    },

    // 添加/编辑岗位
    async savePositionAction(data: any) {
      try {
        // 根据是否有id判断是新增还是编辑
        const res: any = data.id
          ? await userApi.editPosition(data)
          : await userApi.addPosition(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 删除岗位
    async deletePositionAction(data: any) {
      try {
        const res: any = await userApi.deletePosition(data)
        return res
      } catch (error) {
        throw error
      }
    },

    // 获取岗位详情
    async getPositionDetail(id: number): Promise<any> {
      try {
        const res: any = await userApi.viewPosition({ id })
        return res
      } catch (error) {
        throw error
      }
    },

    /**
     * 用户登录操作
     * @param data 登录信息 { username, password, captcha, captchaId }
     * @returns 登录结果
     */
    async loginAction(data: {
      username: string
      password: string
      captcha: string
      captcha_token?: string
      captchaId?: string
    }) {
      try {
        const res: any = await login(data)
        // 确保 res.data.token 存在且不为 undefined
        if (res.data && res.data.token) {
          this.token = res.data.token

          // 只使用LoginResponse接口中定义的属性
          this.userInfo = {
            id: res.data.user_info?.id || 0,
            username: res.data.user_info?.username || '',
            // 优先使用name字段（真实姓名），其次username
            nickname: res.data.user_info?.name || res.data.user_info?.username || '',
            avatar: res.data.user_info?.avatar || '',
            department: res.data.user_info?.department || '',
            position: res.data.user_info?.position || '',
            menu: res.data.menu || [], // 保存菜单信息
          }

          // 保存用户信息到localStorage
          localStorage.setItem('userInfo', JSON.stringify(this.userInfo))

          this.isLogin = true
          localStorage.setItem('token', res.data.token)
        } else {
          throw new Error('Token not provided in response')
        }
        return res
      } catch (error: any) {
        // 不在这里显示错误消息，让调用者处理
        // const errorMsg = error.message || error.msg || '登录失败，请重试';
        // ElMessage.error(errorMsg);
        throw error
      }
    },

    /**
     * 获取验证码
     * @returns 验证码结果
     */
    async getCaptchaAction() {
      try {
        // 添加随机参数防止缓存
        const timestamp = Date.now()

        // 直接获取图片格式的验证码
        try {
          // 使用request方法，确保使用项目中统一的请求配置
          const res: any = await request({
            url: `/api/captcha?timestamp=${timestamp}`,
            method: 'get',
            responseType: 'blob',
            timeout: 10000, // 增加超时时间到10秒
            withCredentials: true, // 维持session一致性
          })

          // 如果res是Blob对象（直接返回的blob数据）
          if (res instanceof Blob) {
            const blob = res
            const imageUrl = URL.createObjectURL(blob)

            // 创建一个随机ID
            const captchaId = `captcha_${timestamp}`

            this.captcha = {
              id: captchaId,
              image: imageUrl,
            }

            return {
              code: 0,
              data: this.captcha,
            }
          }
          // 如果res是对象（可能包含headers和data）
          else if (res && res.data) {
            let blob
            if (res.data instanceof Blob) {
              blob = res.data
            } else {
              // 如果不是Blob，尝试创建一个
              const contentType = 'image/png'
              blob = new Blob([res.data], { type: contentType })
            }

            const imageUrl = URL.createObjectURL(blob)
            const captchaId = `captcha_${timestamp}`

            this.captcha = {
              id: captchaId,
              image: imageUrl,
            }

            return {
              code: 0,
              data: this.captcha,
            }
          } else {
            throw new Error('验证码返回格式不正确')
          }
        } catch (error) {
          throw error
        }
      } catch (error) {
        throw error
      }
    },

    /**
     * 验证验证码
     * 注意：由于后端没有独立的验证码验证接口
     * 验证码验证会在登录请求中一起处理
     * 此方法保留仅用于兼容性
     * @param captchaId 验证码ID
     * @param captchaCode 验证码
     * @returns 验证结果
     */
    async verifyCaptchaAction(captchaId: string, captchaCode: string): Promise<boolean> {
      try {
        // 由于后端没有独立的验证码验证接口
        // 这里直接返回true，验证码验证会在登录请求中一起处理
        return true
      } catch (error) {
        return false
      }
    },

    /**
     * 设置Token
     * @param token 用户token
     */
    setToken(token: string) {
      this.token = token
      localStorage.setItem('token', token)
    },

    /**
     * 设置用户信息
     * @param userInfo 用户信息
     */
    setUserInfo(userInfo: any) {
      if (userInfo) {
        this.userInfo = {
          id: userInfo.id || 0,
          username: userInfo.username || userInfo.name || '',
          // 优先使用name字段（真实姓名），其次username
          nickname: userInfo.name || userInfo.username || '',
          avatar: userInfo.thumb || userInfo.avatar || '',
          department: userInfo.department || userInfo.department_names || '',
          position: userInfo.position || userInfo.position_name || '',
          menu: userInfo.menu || [], // 保存菜单信息
        }
      }
    },

    /**
     * 获取用户信息
     * 依赖request.ts中的拦截器确保整个应用中只会有一个getUserInfo请求在运行
     * @returns 用户信息
     */

    /**
     * getUserInfo方法别名，兼容类型定义
     */
    async getUserInfo(): Promise<{ code: number; msg: string; data?: any }> {
      return this.getUserInfoAction()
    },
    async getUserInfoAction(): Promise<{ code: number; msg: string; data?: any }> {
      // 添加调试日志，追踪调用来源
      try {
        // 优化1: 增强localStorage缓存利用，优先从缓存获取
        const cachedUserInfo = localStorage.getItem('userInfo')
        const token = localStorage.getItem('token')

        // 更严格的缓存检查逻辑
        if (cachedUserInfo && token) {
          try {
            const userInfoObj = JSON.parse(cachedUserInfo)
            if (userInfoObj && userInfoObj.id > 0) {
              // 更新store中的用户信息
              this.userInfo = userInfoObj
              // 直接返回缓存数据，不再发起API请求
              return { code: 0, msg: 'success', data: { admin: userInfoObj } }
            }
          } catch (e) {
            localStorage.removeItem('userInfo')
          }
        }

        // 优化2: 检查是否已有用户信息
        if (this.userInfo && this.userInfo.id > 0) {
          return { code: 0, msg: 'success', data: { admin: this.userInfo } }
        }

        // 直接调用getUserInfo服务，依赖request.ts中的拦截器处理重复请求
        const res = await getUserInfo()
        if (res.code === 0) {
          const adminInfo = res.data.admin
          this.userInfo = {
            id: adminInfo?.id || 0,
            username: adminInfo?.username || '',
            // 优先使用name字段（真实姓名），其次username
            nickname: adminInfo?.name || adminInfo?.username || '',
            avatar: adminInfo?.thumb || adminInfo?.avatar || '',
            department: adminInfo?.department || adminInfo?.department_names || '',
            position: adminInfo?.position || adminInfo?.position_name || '',
            menu: res.data.menu || [], // 保存菜单信息
          }

          // 将用户信息保存到 localStorage，供后续使用
          localStorage.setItem('userInfo', JSON.stringify(this.userInfo))
        } else {
          // 如果返回错误码，抛出错误以便在路由守卫中捕获
          throw new Error(res.msg || '获取用户信息失败')
        }
        return res
      } catch (error: any) {
        // 如果是401错误，说明token已失效
        if (error.response?.status === 401 || error?.response?.data?.code === 401) {
          // 清除本地存储的token和用户信息
          this.token = null
          this.userInfo = { id: 0, username: '', nickname: '', avatar: '' }
          this.isLogin = false
          localStorage.removeItem('token')
          localStorage.removeItem('userInfo')
        }

        throw error
      }
    },

    /**
     * 验证Token有效性
     * @returns Token是否有效
     */
    async validateTokenAction(): Promise<boolean> {
      try {
        // 直接使用getUserInfoAction来验证token有效性并获取用户信息
        // 这样可以避免重复请求
        const res = await this.getUserInfoAction()
        return res.code === 0
      } catch (error: any) {
        // 如果返回401错误，说明token无效
        if (error.response?.status === 401 || error?.response?.data?.code === 401) {
          return false
        }
        // 其他错误可能是网络问题，我们假设token仍然有效
        return true
      }
    },

    /**
     * 重置用户信息请求状态（用于测试或特殊场景）
     */
    resetUserInfoRequestState() {
      resetUserInfo()
    },

    /**
     * 退出登录
     * 修复要点:
     * 1. 清除所有相关数据（token、userInfo、menuList）
     * 2. 重置所有请求状态
     * 3. 确保提示消息显示后再跳转
     */
    logoutAction() {
      // 步骤1: 清除Store状态
      this.token = null
      this.userInfo = { id: 0, username: '', nickname: '', avatar: '' } as any
      this.isLogin = false

      // 步骤2: 清除localStorage所有数据
      localStorage.clear()

      // 步骤3: 重置所有请求状态，确保下次登录可以正常发起请求
      resetAllRequests()

      // 步骤4: 显示成功消息
      ElMessage.success('已退出登录')
    },
  },
  // 添加getters
  getters: {
    isLoggedIn: state => state.isLogin || !!state.token,
  },
})

// 明确导出类型
export type { User, Department, Position }
